package xaj.scc.util.mapping;

import java.util.HashMap;
import java.util.Map;

import xaj.scc.parse.*;

public class Mapping {


	private static Mapping instance = null;
	//Padrao singleton
	public static Mapping getInstance() {
		if (instance == null) {
			instance = new Mapping();
		}
		return instance;
	}

	
	public Map<String, String> nonTerms; 
	public Map<String, String> terms;
	public Map<Integer, String> symbol;
	
	
	/**
	 * Construtor para a classe Mapping
	 * Inicializa os atributos com HashMap 
	 * 
	 */
	private Mapping() {
		nonTerms = new HashMap<String, String>();
		terms = new HashMap<String, String>();
		symbol = new HashMap<Integer,String>();
		
		// VLADIMIR 2009-10-28
		mappingTerm();
		
	}
	/**
	 *Metodo para mapeamento de terminais ,
	 *nao terminais de Java e AspectJ e simbolos
	 * 
	 */
	public void mappingTerm(){
		// OBSERVAR MAPEAMENTO DA LINHA 332

		// /////////////////****************************///////////////
		/* ---------------Mapeamento de nao terminais---------------- */

		// Mapeamento para nao terminais da gramatica do java
		nonTerms.put("goal", "SourceFile");
		nonTerms.put("literal", "polyglot.ast.Lit");
		nonTerms.put("boundary_literal", "polyglot.ast.Lit");
		nonTerms.put("type", "TypeNode");
		nonTerms.put("primitive_type", "TypeNode");
		nonTerms.put("numeric_type", "TypeNode");
		nonTerms.put("integral_type", "TypeNode");
		nonTerms.put("floating_point_type", "TypeNode");
		nonTerms.put("reference_type", "TypeNode");
		nonTerms.put("class_or_interface_type", "TypeNode");
		nonTerms.put("class_type", "TypeNode");
		nonTerms.put("interface_type", "TypeNode");
		nonTerms.put("array_type", "TypeNode");
		nonTerms.put("name", "Name");
		nonTerms.put("simple_name", "Name");
		nonTerms.put("qualified_name", "Name");
		nonTerms.put("compilation_unit", "SourceFile");
		nonTerms.put("package_declaration_opt", "PackageNode");
		nonTerms.put("package_declaration", "PackageNode");
		nonTerms.put("import_declarations_opt", "List");
		nonTerms.put("import_declarations", "List");
		nonTerms.put("type_declarations_opt", "List");
		nonTerms.put("type_declarations", "List");
		nonTerms.put("import_declaration", "Import");
		nonTerms.put("single_type_import_declaration", "Import");
		nonTerms.put("type_import_on_demand_declaration", "Import");
		nonTerms.put("type_declaration", "ClassDecl");
		nonTerms.put("modifiers_opt", "Flags");
		nonTerms.put("modifiers", "Flags");
		nonTerms.put("modifier", "Flags");
		nonTerms.put("class_declaration", "ClassDecl");
		nonTerms.put("super", "TypeNode");
		nonTerms.put("super_opt", "TypeNode");
		nonTerms.put("interfaces", "List");
		nonTerms.put("interfaces_opt", "List");
		nonTerms.put("interface_type_list", "List");
		nonTerms.put("class_body", "ClassBody");
		nonTerms.put("class_body_declarations", "List");
		nonTerms.put("class_body_declarations_opt", "List");
		nonTerms.put("class_body_declaration", "List");
		nonTerms.put("class_member_declaration", "List");
		nonTerms.put("field_declaration", "List");
		nonTerms.put("variable_declarators", "List");
		nonTerms.put("variable_declarator", "VarDeclarator");
		nonTerms.put("variable_declarator_id", "VarDeclarator");
		nonTerms.put("variable_initializer", "Expr");
		nonTerms.put("method_declaration", "MethodDecl");
		nonTerms.put("method_header", "MethodDecl");
		nonTerms.put("formal_parameter_list_opt", "List");
		nonTerms.put("formal_parameter_list", "List");
		nonTerms.put("formal_parameter", "Formal");
		nonTerms.put("throws_opt, throws", "List");
		nonTerms.put("class_type_list", "List");
		nonTerms.put("method_body", "Block");
		nonTerms.put("static_initializer", "Block");
		nonTerms.put("constructor_declaration", "ConstructorDecl");
		nonTerms.put("constructor_body", "Block");
		nonTerms.put("explicit_constructor_invocation", "ConstructorCall");
		nonTerms.put("interface_declaration", "ClassDecl");
		nonTerms.put("extends_interfaces_opt", "List");
		nonTerms.put("extends_interfaces", "List");
		nonTerms.put("interface_body", "ClassBody");
		nonTerms.put("interface_member_declarations_opt", "List");
		nonTerms.put("interface_member_declarations", "List");
		nonTerms.put("interface_member_declaration", "List");
		nonTerms.put("constant_declaration", "List");
		nonTerms.put("abstract_method_declaration", "MethodDecl");
		nonTerms.put("array_initializer", "ArrayInit");
		nonTerms.put("variable_initializers", "List");
		nonTerms.put("block", "Block");
		nonTerms.put("block_statements_opt", "List");
		nonTerms.put("block_statements", "List");
		nonTerms.put("block_statement", "List");
		nonTerms.put("local_variable_declaration_statement", "List");
		nonTerms.put("local_variable_declaration", "List");
		nonTerms.put("statement", "Stmt");
		nonTerms.put("statement_no_short_if", "Stmt");
		nonTerms.put("statement_without_trailing_substatement", "Stmt");
		nonTerms.put("empty_statement", "Empty");
		nonTerms.put("labeled_statement", "Labeled");
		nonTerms.put("labeled_statement_no_short_if", "Labeled");
		nonTerms.put("expression_statement", "Stmt");
		nonTerms.put("statement_expression", "Expr");
		nonTerms.put("if_then_statement", "If");
		nonTerms.put("if_then_else_statement", "If");
		nonTerms.put("if_then_else_statement_no_short_if", "If");
		nonTerms.put("switch_statement", "Switch");
		nonTerms.put("switch_block", "List");
		nonTerms.put("switch_block_statement_groups", "List");
		nonTerms.put("switch_block_statement_group", "List");
		nonTerms.put("switch_labels", "List");
		nonTerms.put("switch_label", "Case");
		nonTerms.put("while_statement", "While");
		nonTerms.put("while_statement_no_short_if", "While");
		nonTerms.put("do_statement", "Do");
		nonTerms.put("for_statement", "For");
		nonTerms.put("for_statement_no_short_if", "For");
		nonTerms.put("for_init_opt", "List");
		nonTerms.put("for_init", "List");
		nonTerms.put("for_update_opt", "List");
		nonTerms.put("for_update", "List");
		nonTerms.put("statement_expression_list", "List");
		nonTerms.put("identifier_opt", "Name");
		nonTerms.put("break_statement", "Branch");
		nonTerms.put("continue_statement", "Branch");
		nonTerms.put("return_statement", "Return");
		nonTerms.put("throw_statement", "Throw");
		nonTerms.put("synchronized_statement", "Synchronized");
		nonTerms.put("try_statement", "Try");
		nonTerms.put("catches_opt", "List");
		nonTerms.put("catches", "List");
		nonTerms.put("catch_clause", "Catch");
		nonTerms.put("finally", "Block");
		nonTerms.put("assert_statement", "Assert");
		nonTerms.put("primary", "Expr");
		nonTerms.put("primary_no_new_array", "Expr");
		nonTerms.put("class_instance_creation_expression", "Expr");
		nonTerms.put("argument_list_opt", "List");
		nonTerms.put("argument_list", "List");
		nonTerms.put("array_creation_expression", "NewArray");
		nonTerms.put("dim_exprs", "List");
		nonTerms.put("dim_expr", "Expr");
		nonTerms.put("dims_opt", "Integer");
		nonTerms.put("dims", "Integer");
		nonTerms.put("field_access", "Field");
		nonTerms.put("method_invocation", "Call");
		nonTerms.put("array_access", "ArrayAccess");
		nonTerms.put("postfix_expression", "Expr");
		nonTerms.put("postincrement_expression", "Unary");
		nonTerms.put("postdecrement_expression", "Unary");
		nonTerms.put("unary_expression", "Expr");
		nonTerms.put("unary_expression_not_plus_minus", "Expr");
		nonTerms.put("preincrement_expression", "Unary");
		nonTerms.put("predecrement_expression", "Unary");
		nonTerms.put("cast_expression", "Cast");
		nonTerms.put("multiplicative_expression", "Expr");
		nonTerms.put("additive_expression", "Expr");
		nonTerms.put("shift_expression", "Expr");
		nonTerms.put("relational_expression", "Expr");
		nonTerms.put("equality_expression", "Expr");
		nonTerms.put("and_expression", "Expr");
		nonTerms.put("exclusive_or_expression", "Expr");
		nonTerms.put("inclusive_or_expression", "Expr");
		nonTerms.put("conditional_and_expression", "Expr");
		nonTerms.put("conditional_or_expression", "Expr");
		nonTerms.put("conditional_expression", "Expr");
		nonTerms.put("assignment_expression", "Expr");
		nonTerms.put("assignment", "Expr");
		nonTerms.put("left_hand_side", "Expr");
		nonTerms.put("assignment_operator", "Assign.Operator");
		nonTerms.put("expression_opt", "Expr");
		nonTerms.put("expression", "Expr");
		nonTerms.put("constant_expression", "Expr");

		// Mapeamento para nao terminais da gram�tica do aspectJ
		nonTerms.put("aspect_declaration", "AspectDecl");
		nonTerms.put("perclause_opt", "PerClause");
		nonTerms.put("perclause", "PerClause");
		nonTerms.put("aspect_body", "AspectBody");
		nonTerms.put("aspect_body_declarations", "List");
		nonTerms.put("aspect_body_declaration", "List");
		nonTerms.put("declare_declaration", "DeclareDecl");
		nonTerms.put("pointcut_declaration", "PointcutDecl");
		nonTerms.put("advice_declaration", "AdviceDecl");
		nonTerms.put("advice_spec", "AdviceSpec");
		nonTerms.put("intertype_member_declaration", "IntertypeDecl");
		nonTerms.put("pointcut_expr", "Pointcut");
		nonTerms.put("and_pointcut_expr", "Pointcut");
		nonTerms.put("unary_pointcut_expr", "Pointcut");
		nonTerms.put("basic_pointcut_expr", "Pointcut");
		nonTerms.put("name_pattern", "NamePattern");
		nonTerms.put("simple_name_pattern", "SimpleNamePattern");
		nonTerms.put("aspectj_reserved_identifier", "Token");
		nonTerms.put("type_pattern_expr", "TypePatternExpr");
		nonTerms.put("or_type_pattern_expr", "TypePatternExpr");
		nonTerms.put("unary_type_pattern_expr", "TypePatternExpr");
		nonTerms.put("basic_type_pattern", "TypePatternExpr");
		nonTerms.put("base_type_pattern", "TypePatternExpr");
		nonTerms.put("classname_pattern_expr_list", "List");
		nonTerms.put("classname_pattern_expr", "ClassnamePatternExpr");
		nonTerms.put("and_classname_pattern_expr", "ClassnamePatternExpr");
		nonTerms.put("unary_classname_pattern_expr", "ClassnamePatternExpr");
		nonTerms.put("basic_classname_pattern", "ClassnamePatternExpr");
		nonTerms.put("classname_pattern_expr_nobang", "ClassnamePatternExpr");
		nonTerms.put("and_classname_pattern_expr_nobang",
				"ClassnamePatternExpr");
		nonTerms.put("modifier_pattern_expr", "List");
		nonTerms.put("throws_pattern_list_opt", "List");
		nonTerms.put("throws_pattern_list", "List");
		nonTerms.put("throws_pattern", "ThrowsPattern");
		nonTerms.put("method_constructor_pattern", "MethodConstructorPattern");
		nonTerms.put("method_pattern", "MethodPattern");
		nonTerms.put("constructor_pattern", "ConstructorPattern");
		nonTerms.put("field_pattern", "FieldPattern");
		nonTerms.put("classtype_dot_new", "ClassTypeDotNew");
		nonTerms.put("classtype_dot_id", "ClassTypeDotId");
		nonTerms.put("formal_pattern_list_opt", "List");
		nonTerms.put("formal_pattern_list", "List");
		nonTerms.put("formal_pattern", "FormalPattern");
		nonTerms.put("type_id_star_list_opt", "List");
		nonTerms.put("type_id_star_list", "List");
		nonTerms.put("type_id_star", "ArgPattern");

		// /////////////////****************************///////////////
		/* ---------------Mapeamento de terminais---------------- */

		// Mapeamento para terminais da gramatica do java
		terms.put("BOOLEAN", "Token");
		terms.put("BYTE", "Token");
		terms.put("SHORT", "Token");
		terms.put("INT", "Token");
		terms.put("LONG", "Token");
		terms.put("CHAR", "Token");
		terms.put("FLOAT", "Token");
		terms.put("DOUBLE", "Token");
		terms.put("LBRACK", "Token");
		terms.put("RBRACK", "Token");
		terms.put("IDENTIFIER", "Identifier");
		terms.put("DOT", "Token");
		terms.put("SEMICOLON", "Token");
		terms.put("MULT", "Token");
		terms.put("COMMA", "Token");
		terms.put("LBRACE", "Token");
		terms.put("RBRACE", "Token");
		terms.put("EQ", "Token");
		terms.put("LPAREN", "Token");
		terms.put("RPAREN", "Token");
		terms.put("COLON", "Token");
		terms.put("PACKAGE", "Token");
		terms.put("IMPORT", "Token");
		terms.put("PUBLIC", "Token");
		terms.put("PROTECTED", "Token");
		terms.put("PRIVATE", "Token");
		terms.put("STATIC", "Token");
		terms.put("ABSTRACT", "Token");
		terms.put("FINAL", "Token");
		terms.put("NATIVE", "Token");
		terms.put("SYNCHRONIZED", "Token");
		terms.put("TRANSIENT", "Token");
		terms.put("VOLATILE", "Token");
		terms.put("CLASS", "Token");
		terms.put("EXTENDS", "Token");
		terms.put("IMPLEMENTS", "Token");
		terms.put("VOID", "Token");
		terms.put("THROWS", "Token");
		terms.put("THIS", "Token");
		terms.put("SUPER", "Token");
		terms.put("INTERFACE", "Token");
		terms.put("IF", "Token");
		terms.put("ELSE", "Token");
		terms.put("SWITCH", "Token");
		terms.put("CASE", "Token");
		terms.put("DEFAULT", "Token");
		terms.put("DO", "Token");
		terms.put("WHILE", "Token");
		terms.put("FOR", "Token");
		terms.put("BREAK", "Token");
		terms.put("CONTINUE", "Token");
		terms.put("RETURN", "Token");
		terms.put("THROW", "Token");
		terms.put("TRY", "Token");
		terms.put("CATCH", "Token");
		terms.put("FINALLY", "Token");
		terms.put("NEW", "Token");
		terms.put("PLUSPLUS", "Token");
		terms.put("MINUSMINUS", "Token");
		terms.put("PLUS", "Token");
		terms.put("MINUS", "Token");
		terms.put("COMP", "Token");
		terms.put("NOT", "Token");
		terms.put("DIV", "Token");
		terms.put("MOD", "Token");
		terms.put("LSHIFT", "Token");
		terms.put("RSHIFT", "Token");
		terms.put("URSHIFT", "Token");
		terms.put("LT", "Token");
		terms.put("GT", "Token");
		terms.put("LTEQ", "Token");
		terms.put("GTEQ", "Token");
		terms.put("INSTANCEOF", "Token");
		terms.put("EQEQ", "Token");
		terms.put("NOTEQ", "Token");
		terms.put("AND", "Token");
		terms.put("XOR", "Token");
		terms.put("OR", "Token");
		terms.put("ANDAND", "Token");
		terms.put("OROR", "Token");
		terms.put("QUESTION", "Token");
		terms.put("MULTEQ", "Token");
		terms.put("DIVEQ", "Token");
		terms.put("MODEQ", "Token");
		terms.put("PLUSEQ", "Token");
		terms.put("MINUSEQ", "Token");
		terms.put("LSHIFTEQ", "Token");
		terms.put("RSHIFTEQ", "Token");
		terms.put("URSHIFTEQ", "Token");
		terms.put("ANDEQ", "Token");
		terms.put("XOREQ", "Token");
		terms.put("OREQ", "Token");
		terms.put("INTEGER_LITERAL", "polyglot.lex.IntegerLiteral");
		terms.put("INTEGER_LITERAL_BD", "polyglot.lex.IntegerLiteral");
		terms.put("LONG_LITERAL", "polyglot.lex.LongLiteral");
		terms.put("LONG_LITERAL_BD", "polyglot.lex.LongLiteral");
		terms.put("DOUBLE_LITERAL", "polyglot.lex.DoubleLiteral");
		terms.put("FLOAT_LITERAL", "polyglot.lex.FloatLiteral");
		terms.put("BOOLEAN_LITERAL", "polyglot.lex.BooleanLiteral");
		terms.put("CHARACTER_LITERAL", "polyglot.lex.CharacterLiteral");
		terms.put("STRING_LITERAL", "polyglot.lex.StringLiteral");
		terms.put("NULL_LITERAL", "polyglot.lex.NullLiteral");
		terms.put("STRICTFP", "Token");
		terms.put("ASSERT", "Token");
		// terms.put("CONST", ""); UNUSED
		// terms.put("GOTO", ""); UNUSED

		// Mapeamento para terminais da gram�tica do aspectJ
		terms.put("ASPECT", "Token");
		terms.put("PRIVILEGED", "Token");
		terms.put("AFTER", "Token");
		terms.put("AROUND", "Token");
		terms.put("BEFORE", "Token");
		terms.put("DECLARE", "Token");
		terms.put("ISSINGLETON", "Token");
		terms.put("PERCFLOW", "Token");
		terms.put("PERCFLOWBELOW", "Token");
		terms.put("PERTARGET", "Token");
		terms.put("PERTHIS", "Token");
		terms.put("POINTCUT", "Token");
		terms.put("PROCEED", "Token");
		terms.put("THISENCLOSINGJOINPOINTSTATICPART", "Token");
		terms.put("THISJOINPOINT", "Token");
		terms.put("THISJOINPOINTSTATICPART", "Token");
		terms.put("PC_ADVICEEXECUTION", "Token");
		terms.put("PC_ARGS", "Token");
		terms.put("PC_CALL", "Token");
		terms.put("PC_CFLOW", "Token");
		terms.put("PC_CFLOWBELOW", "Token");
		terms.put("PC_ERROR", "Token");
		terms.put("PC_EXECUTION", "Token");
		terms.put("PC_GET", "Token");
		terms.put("PC_HANDLER", "Token");
		terms.put("PC_IF", "Token");
		terms.put("PC_INITIALIZATION", "Token");
		terms.put("PC_PARENTS", "Token");
		terms.put("PC_PRECEDENCE", "Token");
		terms.put("PC_PREINITIALIZATION", "Token");
		terms.put("PC_RETURNING", "Token");
		terms.put("PC_SET", "Token");
		terms.put("PC_SOFT", "Token");
		terms.put("PC_STATICINITIALIZATION", "Token");
		terms.put("PC_TARGET", "Token");
		terms.put("PC_THIS", "Token");
		terms.put("PC_THROWING", "Token");
		terms.put("PC_WARNING", "Token");
		terms.put("PC_WITHIN", "Token");
		terms.put("PC_WITHINCODE", "Token");
		terms.put("PC_DOTDOT", "Token");
		terms.put("PC_NOT", "Token");
		terms.put("PC_ANDAND", "Token");
		terms.put("PC_OROR", "Token");
		terms.put("PC_PLUS", "Token");
		terms.put("PC_MULT", "Token");
		terms.put("IDENTIFIERPATTERN", "Identifier");
		
		
		///////////////*************************************//////////////
		/*-----------------Mapeamento dos simbolos constantes-----------*/
		symbol.put(sym.LBRACK, "LBRACK");
		symbol.put(sym.PC_RETURNING,"PC_RETURNING");
		symbol.put(sym.BYTE,"BYTE");
		symbol.put(sym.PERCFLOWBELOW, "PERCFLOWBELOW");
		symbol.put(sym.IMPLEMENTS, "IMPLEMENTS");
		symbol.put(sym.LBRACE, "LBRACE");
		symbol.put(sym.FLOAT, "FLOAT");
		symbol.put(sym.AROUND, "AROUND");
		symbol.put(sym.PC_ERROR, "PC_ERROR");
		symbol.put(sym.GT, "GT");
		symbol.put(sym.PC_CFLOW,"PC_CFLOW");
		symbol.put(sym.MULT,"MULT");		
		symbol.put(sym.URSHIFTEQ,"URSHIFTEQ");
		symbol.put(sym.VOLATILE,"VOLATILE");
		symbol.put(sym.DIVEQ,"DIVEQ");
		symbol.put(sym.PC_INITIALIZATION,"PC_INITIALIZATION");
		symbol.put(sym.STRING_LITERAL,"STRING_LITERAL");
		symbol.put(sym.PC_PREINITIALIZATION,"PC_PREINITIALIZATION");
		symbol.put(sym.PROTECTED,"PROTECTED");
		symbol.put(sym.RPAREN,"RPAREN");
		symbol.put(sym.PC_ARGS,"PC_ARGS");
		symbol.put(sym.PRIVILEGED,"PRIVILEGED");
		symbol.put(sym.POINTCUT,"POINTCUT");
		symbol.put(sym.SHORT,"SHORT");
		symbol.put(sym.PERTARGET,"PERTARGET");
		symbol.put(sym.PUBLIC,"PUBLIC");
		symbol.put(sym.PC_THIS,"PC_THIS");
		symbol.put(sym.FLOAT_LITERAL,"FLOAT_LITERAL");
		symbol.put(sym.ANDEQ,"ANDEQ");
		symbol.put(sym.GOTO,"GOTO");
		symbol.put(sym.THISJOINPOINT,"THISJOINPOINT");
		symbol.put(sym.EQ,"EQ");
		symbol.put(sym.GRAMMAR,"GRAMMAR");
		symbol.put(sym.PC_TARGET,"PC_TARGET");
		symbol.put(sym.LONG_LITERAL_BD,"LONG_LITERAL_BD");
		symbol.put(sym.MOD,"MOD");
		symbol.put(sym.PC_SET,"PC_SET");
		symbol.put(sym.PC_CFLOWBELOW,"PC_CFLOWBELOW");
		symbol.put(sym.PC_WARNING,"PC_WARNING");
		symbol.put(sym.DIV,"DIV");
		symbol.put(sym.PERTHIS,"PERTHIS");
		symbol.put(sym.RSHIFT,"RSHIFT");
		symbol.put(sym.AFTER,"AFTER");
		symbol.put(sym.PC_PLUS,"PC_PLUS");
		symbol.put(sym.SWITCH,"SWITCH");
		symbol.put(sym.PC_DOTDOT,"PC_DOTDOT");
		symbol.put(sym.PRIVATE,"PRIVATE");
		symbol.put(sym.DO,"DO");
		symbol.put(sym.EOF,"EOF");
		symbol.put(sym.FINALLY,"FINALLY");
		symbol.put(sym.MINUS,"MINUS");
		symbol.put(sym.INT,"INT");
		symbol.put(sym.QUESTION,"QUESTION");
		symbol.put(sym.INSTANCEOF,"INSTANCEOF");
		symbol.put(sym.IMPORT,"IMPORT");
		symbol.put(sym.VOID,"VOID");
		symbol.put(sym.PC_GET,"PC_GET");
		symbol.put(sym.PACKAGE,"PACKAGE");
		symbol.put(sym.BOOLEAN_LITERAL,"BOOLEAN_LITERAL");
		symbol.put(sym.URSHIFT,"URSHIFT");
		symbol.put(sym.PC_WITHIN,"PC_WITHIN");
		symbol.put(sym.ELSE,"ELSE");
		symbol.put(sym.TRY,"TRY");
		symbol.put(sym.CHAR,"CHAR");
		symbol.put(sym.OR,"OR");
		symbol.put(sym.ASSERT,"ASSERT");
		symbol.put(sym.PC_PARENTS,"PC_PARENTS");
		symbol.put(sym.PLUSPLUS,"PLUSPLUS");
		symbol.put(sym.PC_ADVICEEXECUTION,"PC_ADVICEEXECUTION");
		symbol.put(sym.AND,"AND");
		symbol.put(sym.RSHIFTEQ,"RSHIFTEQ");
		symbol.put(sym.THIS,"THIS");
		symbol.put(sym.PC_THROWING,"PC_THROWING");
		symbol.put(sym.TRANSIENT,"TRANSIENT");
		symbol.put(sym.BOOLEAN,"BOOLEAN");
		symbol.put(sym.PC_PRECEDENCE,"PC_PRECEDENCE");
		symbol.put(sym.NEW,"NEW");
		symbol.put(sym.INTEGER_LITERAL_BD,"INTEGER_LITERAL_BD");
		symbol.put(sym.STRICTFP,"STRICTFP");
		symbol.put(sym.SUPER,"SUPER");
		symbol.put(sym.MINUSEQ,"MINUSEQ");
		symbol.put(sym.PC_OROR,"PC_OROR");
		symbol.put(sym.INTERFACE,"INTERFACE");
		symbol.put(sym.PC_IF,"PC_IF");
		symbol.put(sym.OVERRIDES,"OVERRIDES");
		symbol.put(sym.PC_STATICINITIALIZATION,"PC_STATICINITIALIZATION");
		symbol.put(sym.CASE,"CASE");
		symbol.put(sym.PLUSEQ,"PLUSEQ");
		symbol.put(sym.PC_EXECUTION,"PC_EXECUTION");
		symbol.put(sym.PLUS,"PLUS");
		symbol.put(sym.THROW,"THROW");
		symbol.put(sym.CLASS,"CLASS");
		symbol.put(sym.LPAREN,"LPAREN");
		symbol.put(sym.NULL_LITERAL,"NULL_LITERAL");
		symbol.put(sym.RBRACK,"RBRACK");
		symbol.put(sym.NOTEQ,"NOTEQ");
		symbol.put(sym.THISJOINPOINTSTATICPART,"THISJOINPOINTSTATICPART");
		symbol.put(sym.BREAK,"BREAK");
		symbol.put(sym.WHILE,"WHILE");
		symbol.put(sym.RBRACE,"RBRACE");
		symbol.put(sym.OREQ,"OREQ");
		symbol.put(sym.CONST,"CONST");
		symbol.put(sym.XOR,"XOR");
		symbol.put(sym.PC_SOFT,"PC_SOFT");
		symbol.put(sym.THROWS,"THROWS");
		symbol.put(sym.PERCFLOW,"PERCFLOW");
		symbol.put(sym.LSHIFTEQ,"LSHIFTEQ");
		symbol.put(sym.COMMA,"COMMA");
		symbol.put(sym.ISSINGLETON,"ISSINGLETON");
		symbol.put(sym.LT,"LT");
		symbol.put(sym.MINUSMINUS,"MINUSMINUS");
		symbol.put(sym.CHARACTER_LITERAL,"CHARACTER_LITERAL");
		symbol.put(sym.NATIVE,"NATIVE");
		symbol.put(sym.PROCEED,"PROCEED");
		symbol.put(sym.IDENTIFIER,"IDENTIFIER");
		symbol.put(sym.NOT,"NOT");
		symbol.put(sym.PC_HANDLER,"PC_HANDLER");
		symbol.put(sym.LSHIFT,"LSHIFT");
		symbol.put(sym.BEFORE,"BEFORE");
		symbol.put(sym.RETURN,"RETURN");
		symbol.put(sym.LONG,"LONG");
		symbol.put(sym.PC_WITHINCODE,"PC_WITHINCODE");
		symbol.put(sym.FOR,"FOR");
		symbol.put(sym.IDENTIFIERPATTERN,"IDENTIFIERPATTERN");
		symbol.put(sym.MULTEQ,"MULTEQ");
		symbol.put(sym.XOREQ,"XOREQ");
		symbol.put(sym.OROR,"OROR");
		symbol.put(sym.DOT,"DOT");
		symbol.put(sym.PC_MULT,"PC_MULT");
		symbol.put(sym.ABSTRACT,"ABSTRACT");
		symbol.put(sym.DOUBLE,"DOUBLE");
		symbol.put(sym.SYNCHRONIZED,"SYNCHRONIZED");
		symbol.put(sym.PC_CALL,"PC_CALL");
		symbol.put(sym.CONTINUE,"CONTINUE");
		symbol.put(sym.CATCH,"CATCH");
		symbol.put(sym.GTEQ,"GTEQ");
		symbol.put(sym.INTEGER_LITERAL,"INTEGER_LITERAL");
		symbol.put(sym.COMP,"COMP");
		symbol.put(sym.LONG_LITERAL,"LONG_LITERAL");
		symbol.put(sym.SEMICOLON,"SEMICOLON");
		symbol.put(sym.DECLARE,"DECLARE");
		symbol.put(sym.error,"error");
		symbol.put(sym.DOUBLE_LITERAL,"DOUBLE_LITERAL");
		symbol.put(sym.LTEQ,"LTEQ");
		symbol.put(sym.IF,"IF");
		symbol.put(sym.FINAL,"FINAL");
		symbol.put(sym.STATIC,"STATIC");
		symbol.put(sym.EQEQ,"EQEQ");
		symbol.put(sym.DEFAULT,"DEFAULT");
		symbol.put(sym.THISENCLOSINGJOINPOINTSTATICPART,"THISENCLOSINGJOINPOINTSTATICPART");
		symbol.put(sym.COLON,"COLON");
		symbol.put(sym.ANDAND,"ANDAND");
		symbol.put(sym.PC_NOT,"PC_NOT");
		symbol.put(sym.ASPECT,"ASPECT");
		symbol.put(sym.PC_ANDAND,"PC_ANDAND");
		symbol.put(sym.EXTENDS,"EXTENDS");
		symbol.put(sym.MODEQ,"MODEQ");
	
	}
	
/**
 * Metodo para mapeamento dinamico
 * @param term- chave do mapeamento , para simbolos tambem deve ser passado como string
 * @param type- define o mapeamento da chave
 * @param where- define em que Hash efetuar o mapeamento
 * 
 */
	void mappingNew(String term, String type, String where) {

		if (where == "terminal")
			terms.put(term, type);

		else if(where == "symbol")
			symbol.put(Integer.parseInt(term), type);
		else
			nonTerms.put(term, type);

	}
	
	

}
